/** * Description: 用户设置弹框组件 * Date: 2025/2/15 */

<template>
  <MyDiaLog
    :visible="visible"
    titleName="系统设置"
    :width="900"
    :zIndex="1000"
    @close="closeDialog">
    <!-- 弹框内容区 -->
    <div class="dialog-content">
      <!-- 标签页容器 -->
      <TabsContainer
        :tabs="tabs"
        :activeTabIndex.sync="activeTabIndex"
        :disabled="monitoringStarted"
        :eitChangeRate="eitChangeRate"
        :selectedBrain="selectedBrain"
        @tab-changed="handleTabChanged">
        <!-- 系统灵敏度 -->
        <div v-if="activeTabIndex === 0" class="tab-pane">
          <div class="brain-tabs">
            <div
              :class="['brain-tab', { active: selectedBrain === 'left' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('left')">
              左脑
            </div>
            <div
              :class="['brain-tab', { active: selectedBrain === 'right' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('right')">
              右脑
            </div>
          </div>
          <div class="chart-container">
            <l-echart ref="chartRef" @finished="initChart" v-if="activeTabIndex === 0"></l-echart>
          </div>
        </div>

        <!-- 系统稳定性 -->
        <div v-if="activeTabIndex === 1" class="tab-pane">
          <div class="brain-tabs">
            <div
              :class="['brain-tab', { active: selectedBrain === 'left' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('left')">
              左脑
            </div>
            <div
              :class="['brain-tab', { active: selectedBrain === 'right' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('right')">
              右脑
            </div>
          </div>
          <div class="chart-container">
            <l-echart ref="chartRef1" @finished="initChart1" v-if="activeTabIndex === 1"></l-echart>
          </div>
          <div class="timer-info">
            <div class="timer-item">
              <span class="label">开始时间:</span>
              <span class="value">{{ monitoringStarted ? startTimeFormatted : '--:--:--' }}</span>
            </div>
            <div class="timer-item">
              <span class="label">监测计时:</span>
              <span class="value">{{ monitoringStarted ? countdownTimeFormatted1 : '01:00:00' }}</span>
            </div>
          </div>
        </div>

        <!-- 测量精度 -->
        <div v-if="activeTabIndex === 2" class="tab-pane">
          <div class="brain-tabs">
            <div
              :class="['brain-tab', { active: selectedBrain === 'left' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('left')">
              左脑
            </div>
            <div
              :class="['brain-tab', { active: selectedBrain === 'right' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('right')">
              右脑
            </div>
          </div>
          <div class="chart-container">
            <l-echart ref="chartRef2" @finished="initChart2" v-if="activeTabIndex === 2"></l-echart>
          </div>
          <div class="timer-info">
            <div class="timer-item">
              <span class="label">开始时间:</span>
              <span class="value">{{ monitoringStarted ? startTimeFormatted : '--:--:--' }}</span>
            </div>
            <div class="timer-item">
              <span class="label">监测计时:</span>
              <span class="value">{{ monitoringStarted ? countdownTimeFormatted2 : '00:20:00' }}</span>
            </div>
          </div>
        </div>

        <!-- 热稳定性测试 -->
        <div v-if="activeTabIndex === 3" class="tab-pane">
          <div class="brain-tabs">
            <div
              :class="['brain-tab', { active: selectedBrain === 'left' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('left')">
              左脑
            </div>
            <div
              :class="['brain-tab', { active: selectedBrain === 'right' }, { disabled: monitoringStarted }]"
              @click="!monitoringStarted && switchBrain('right')">
              右脑
            </div>
          </div>
          <div class="chart-container">
            <l-echart ref="chartRef3" @finished="initChart3" v-if="activeTabIndex === 3"></l-echart>
          </div>
        </div>

        <!-- 工装 -->
        <div v-if="activeTabIndex === 4" class="tab-pane">
          <FixtureTab />
        </div>
      </TabsContainer>
    </div>

    <!-- 弹框底部按钮区 -->
    <div class="dialog-footer">
      <MonitoringControl
        :is-fixture-tab="activeTabIndex === 4"
        :monitoring-started.sync="monitoringStarted"
        :from-close-button.sync="fromCloseButton"
        :selected-brain="selectedBrain"
        @monitoring-started="handleMonitoringStarted"
        @monitoring-stopped="handleMonitoringStopped"
        @clear-impedance-data="clearImpedanceData"
        @close="closeDialog">
      </MonitoringControl>

    </div>
  </MyDiaLog>
</template>

<script>
import MyDiaLog from '@/components/MyDiaLog/MyDiaLog.vue'
import FixtureTab from '@/pages/userMenu/components/FixtureTab.vue'
import { mapState, mapMutations } from 'vuex'
import { ab2hex, checkPackage, convertFloat, writeBLEState } from '@/public/BluetoothFun'

// 导入新创建的组件和服务
import TabsContainer from './settings/TabsContainer.vue'
import BrainChart from './settings/BrainChart.vue'
import ThermalStabilityChart from './settings/ThermalStabilityChart.vue'
import MonitoringControl from './settings/MonitoringControl.vue'
import * as echarts from '@/uni_modules/lime-echart/static/echarts.min'

// 导入图表管理器
import { chartManager, ChartState } from '@/utils/chart/chartManager'

// 左脑数据
let LeftBrainData = []
// 右脑数据
let RightBrainData = []
// 设置数据点最大限制，防止内存溢出
const MAX_DATA_POINTS = 10000
// 设置数据降采样触发阈值（当数据达到最大限制的80%时开始降采样）
const DOWNSAMPLING_THRESHOLD = MAX_DATA_POINTS * 0.8
// 降采样后保留的数据比例
let currentSamplingRate = 1 // 初始不降采样

export default {
  name: 'SettingsDialog',

  components: {
    MyDiaLog,
    FixtureTab,
    TabsContainer,
    BrainChart,
    ThermalStabilityChart,
    MonitoringControl,
  },

  props: {
    visible: {
      type: Boolean,
      default: false,
    },
  },

  computed: {
    // 从Vuex状态管理器中映射需要的状态
    ...mapState(['isConnected', 'originalData']),
    
    // 格式化开始时间
    startTimeFormatted() {
      if (!this.startTime) return '--:--:--';
      const date = new Date(this.startTime);
      const hours = date.getHours().toString().padStart(2, '0');
      const minutes = date.getMinutes().toString().padStart(2, '0');
      const seconds = date.getSeconds().toString().padStart(2, '0');
      return `${hours}:${minutes}:${seconds}`;
    },
    
    // 系统稳定性倒计时格式化（1小时）
    countdownTimeFormatted1() {
      const totalSeconds = 3600 - this.monitorTime; // 1小时 = 3600秒
      if (totalSeconds <= 0) return '00:00:00';
      
      const hours = Math.floor(totalSeconds / 3600).toString().padStart(2, '0');
      const minutes = Math.floor((totalSeconds % 3600) / 60).toString().padStart(2, '0');
      const seconds = Math.floor(totalSeconds % 60).toString().padStart(2, '0');
      return `${hours}:${minutes}:${seconds}`;
    },
    
    // 测量精度倒计时格式化（20分钟）
    countdownTimeFormatted2() {
      const totalSeconds = 1200 - this.monitorTime; // 20分钟 = 1200秒
      if (totalSeconds <= 0) return '00:00:00';
      
      const hours = Math.floor(totalSeconds / 3600).toString().padStart(2, '0');
      const minutes = Math.floor((totalSeconds % 3600) / 60).toString().padStart(2, '0');
      const seconds = Math.floor(totalSeconds % 60).toString().padStart(2, '0');
      return `${hours}:${minutes}:${seconds}`;
    }
  },

  watch: {
    originalData(newValue) {
      console.log('接收的数据', ab2hex(newValue))
      this.checkFormat(newValue)
    },

  },

  data() {
    return {
      activeTabIndex: 0, // 当前激活的标签页索引
      selectedBrain: 'left', // 当前选择的脑区，默认为左脑
      tabs: [
        { name: '系统灵敏度', key: 'sensitivity' },
        { name: '系统稳定性', key: 'stability' },
        { name: '测量精度', key: 'accuracy' },
        { name: '热稳定性测试', key: 'thermalStability' },
        { name: '工装', key: 'fixture' },
      ],

      // 图表实例状态
      chartInitialized: false,
      chart1Initialized: false,
      chart2Initialized: false,
      chart3Initialized: false,

      // EIT值变化率
      eitChangeRate: '0%',
      // 存储监测结束时的最终变化率，分别按标签页和脑区存储
      finalEitChangeRates: {
        left: ['0%', '0%', '0%', '0%'], // 对应四个标签页的左脑最终变化率
        right: ['0%', '0%', '0%', '0%'], // 对应四个标签页的右脑最终变化率
      },
      
      // 标记当前变化率是否为最终保存的值
      isShowingFinalRate: false,

      // 监测状态
      monitoringStarted: false,
      fromCloseButton: false, // 标记停止监测确认弹框是否来自关闭按钮
      
      // 性能优化：添加时间戳，用于控制更新频率
      lastLeftUpdateTime: null,
      lastRightUpdateTime: null,
      
      // 添加实时阻抗值
      currentLeftImpedance: 0,
      currentRightImpedance: 0,
      
      // 添加监测时间相关数据
      startTime: null, // 开始监测的时间
      monitorTime: 0, // 监测时长（秒）
      timerInterval: null, // 计时器
      
      // 内存回收计时器
      memoryCleanupInterval: null,
      
      // 减少更新次数计数器
      updateCounter: 0,
      updateThreshold: 1, // 初始时每次数据都更新图表，随着时间推移会增加阈值
      
      // 图表更新频率阶段
      updatePhases: [
        { time: 300, threshold: 2 },     // 5分钟后：每2次更新一次
        { time: 600, threshold: 5 },     // 10分钟后：每5次更新一次
        { time: 1800, threshold: 10 },   // 30分钟后：每10次更新一次
        { time: 3600, threshold: 20 },   // 1小时后：每20次更新一次
        { time: 7200, threshold: 50 }    // 2小时后：每50次更新一次
      ],

      // 添加性能监控相关变量
      lastRenderTime: 0,
      renderDuration: 0,
      slowRenderCount: 0,
      performanceMode: false,

      option: {
        title: { text: '' },
        tooltip: {
          trigger: 'axis',
          show: false, // 禁用提示框
        },
        grid: {
          top: '5%',
          left: '3%',
          right: '4%',
          bottom: '0%',
          containLabel: true,
        },
        xAxis: {
          type: 'category',
          boundaryGap: true,
          data: [], // 初始为空数组，在updateChart方法中动态设置
          axisLabel: {
            color: '#666',
            formatter: function (value) {
              return value
            },
            interval: 'auto', // 自动计算标签间隔，避免标签重叠
          },
          silent: true, // 禁用x轴交互
        },
        yAxis: {
          type: 'value',
          name: '阻抗值',
          min: 0,
          axisLabel: {
            color: '#666',
          },
          silent: true, // 禁用y轴交互
        },
        series: [
          {
            name: '阻抗值',
            type: 'line',
            showSymbol: false,
            data: [], // 默认为空数组，不显示任何数据点
            lineStyle: {
              width: 3,
              color: '#4de6c2',
            },
            symbol: 'circle',
            symbolSize: 6,
            itemStyle: {
              color: '#4de6c2',
            },
            silent: true, // 禁用系列交互
          },
        ],
        silent: true, // 禁用整个图表的交互
        animation: false, // 禁用动画
        hoverLayerThreshold: Infinity, // 禁用hover层
        renderer: 'canvas', // 使用canvas渲染，性能更好
      },
    }
  },

  methods: {
    // 从Vuex映射需要的mutations
    ...mapMutations(['setIsConnected']),

    /**
     * 检查接收到的数据格式是否正确，并进行相应处理
     * @param {ArrayBuffer} array - 接收到的原始数据
     */
    checkFormat(array) {
      let arrays = Array.prototype.slice.call(new Uint8Array(array))
      let myArr = []
      myArr.push(...arrays)
      let res = checkPackage(myArr)
      console.log('res', res)
      // 如果数据类型为0x04 左脑数据采集
      if (res[3] === 0x04) this.LeftAnalyticData(res)
      // 如果数据类型为0x05 右脑数据采集
      if (res[3] === 0x05) this.RightAnalyticData(res)
    },


    LeftAnalyticData(array){
      try {
        // 解析数据前端部分
        let decode_front = array.slice(4, -3)
        // 获取左脑阻抗值，保留小数点后2位
        let fixL = parseFloat(convertFloat(decode_front.slice(0, 8).reverse()).toFixed(2))
        this.currentLeftImpedance = fixL
        // 检查数据有效性
        if (isNaN(fixL) || !isFinite(fixL)) {
          console.warn('接收到无效的左脑数据:', fixL)
          return
        }
        
        // 添加数据
        LeftBrainData.push(fixL)
        
        // 当数据量接近或超过最大限制时进行智能降采样
        if (LeftBrainData.length > DOWNSAMPLING_THRESHOLD) {
          this.intelligentDownsampling('left')
        }
        
        // 限制数据更新频率，避免频繁渲染导致崩溃
        const now = Date.now();
        if (!this.lastLeftUpdateTime || now - this.lastLeftUpdateTime >= 200) {
          this.lastLeftUpdateTime = now;
          
          // 如果当前选择的是左脑，则更新图表
          if (this.selectedBrain === 'left') {
            try {
              // 增加计数器，减少刷新频率
              this.updateCounter++;
              if (this.updateCounter % this.updateThreshold !== 0) {
                return; // 不满足更新条件，直接返回
              }
              
              // 只更新当前激活标签页的图表
              if (this.activeTabIndex === 0 && this.chartInitialized) {
                this.updateChart(LeftBrainData)
              } else if (this.activeTabIndex === 1 && this.chart1Initialized) {
                this.updateChart1(LeftBrainData)
              } else if (this.activeTabIndex === 2 && this.chart2Initialized) {
                this.updateChart2(LeftBrainData)
              } else if (this.activeTabIndex === 3 && this.chart3Initialized) {
                this.updateChart3(LeftBrainData)
              }
              
              // 更新EIT变化率
              this.calculateEITChangeRate()
            } catch (error) {
              console.error('更新左脑图表时发生错误:', error)
            }
          }
        }
      } catch (error) {
        console.error('处理左脑数据时发生错误:', error)
      }
    },

    RightAnalyticData(array){
      try {
        // 解析数据前端部分
        let decode_front = array.slice(4, -3)
        let fixR = parseFloat(convertFloat(decode_front.slice(0, 8).reverse()).toFixed(2))
        this.currentRightImpedance = fixR
        // 检查数据有效性
        if (isNaN(fixR) || !isFinite(fixR)) {
          console.warn('接收到无效的右脑数据:', fixR)
          return
        }
        
        // 添加数据
        RightBrainData.push(fixR)
        
        // 当数据量接近或超过最大限制时进行智能降采样
        if (RightBrainData.length > DOWNSAMPLING_THRESHOLD) {
          this.intelligentDownsampling('right')
        }
        
        // 限制数据更新频率，避免频繁渲染导致崩溃
        const now = Date.now();
        if (!this.lastRightUpdateTime || now - this.lastRightUpdateTime >= 300) { // A: 右脑更新频率降低到300ms
          this.lastRightUpdateTime = now;
          
          // 如果当前选择的是右脑，则更新图表
          if (this.selectedBrain === 'right') {
            try {
              // 增加计数器，减少刷新频率
              this.updateCounter++;
              if (this.updateCounter % this.updateThreshold !== 0) {
                return; // 不满足更新条件，直接返回
              }
              
              // 只更新当前激活标签页的图表
              if (this.activeTabIndex === 0 && this.chartInitialized) {
                this.updateChart(RightBrainData)
              } else if (this.activeTabIndex === 1 && this.chart1Initialized) {
                this.updateChart1(RightBrainData)
              } else if (this.activeTabIndex === 2 && this.chart2Initialized) {
                this.updateChart2(RightBrainData)
              } else if (this.activeTabIndex === 3 && this.chart3Initialized) {
                this.updateChart3(RightBrainData)
              }
              
              // 更新EIT变化率
              this.calculateEITChangeRate()
            } catch (error) {
              console.error('更新右脑图表时发生错误:', error)
            }
          }
        }
      } catch (error) {
        console.error('处理右脑数据时发生错误:', error)
      }
    },    async initChart() {
      if (!this.$refs.chartRef) {
        console.warn('系统灵敏度图表引用不存在，跳过初始化');
        return;
      }
      
      try {
        // 使用图表管理器注册并初始化图表
        const chartId = `sensitivity-${this.selectedBrain}`;
        
        // 监测性能
        const startTime = Date.now();
        console.log(`开始初始化系统灵敏度图表: ${chartId}`);
        
        // 注册图表前确保之前的图表实例已被正确销毁
        if (chartManager.isChartReady(chartId)) {
          await chartManager.disposeChart(chartId);
        }
        
        const chart = await chartManager.registerChart(chartId, this.$refs.chartRef, async (echarts) => {
          try {
            // 调用echart组件的初始化方法
            const chartInstance = await this.$refs.chartRef.init(echarts);
            return chartInstance;
          } catch (err) {
            console.error('初始化图表实例失败:', err);
            return null;
          }
        });
        
        // 计算初始化时间
        const initTime = Date.now() - startTime;
        console.log(`系统灵敏度图表初始化耗时: ${initTime}ms`);
        
        if (!chart) {
          console.error('系统灵敏度图表初始化失败，无法获取图表实例');
          this.chartInitialized = false;
          return;
        }
        
        // 初始化图表
        const initialOption = {
          ...this.option,
          xAxis: {
            ...this.option.xAxis,
            data: Array.from({ length: 101 }, (_, i) => i) // 初始显示0-100的x轴
          },
          series: [{
            ...this.option.series[0],
            data: [] // 初始为空
          }]
        };
        
        // 更新图表选项
        try {
          await chartManager.updateChart(chartId, initialOption);
          
          // 标记图表已初始化
          this.chartInitialized = true;
          
          // 获取当前数据并显示
          if (this.activeTabIndex === 0) {
            const data = this.selectedBrain === 'left' ? LeftBrainData : RightBrainData;
            // 延迟一下更新数据，确保图表已完全渲染
            setTimeout(() => {
              this.updateChart(data);
            }, 50);
          }
          
          console.log('系统灵敏度图表初始化完成');
        } catch (updateError) {
          console.error('更新系统灵敏度图表选项失败:', updateError);
        }
      } catch (error) {
        console.error('初始化系统灵敏度图表失败:', error);
        this.chartInitialized = false;
      }
    },
    
    /**
     * 更新图表数据
     * @param {Array} data - 要显示的数据数组
     */    updateChart(data) {
      try {
        const chartId = `sensitivity-${this.selectedBrain}`;
        
        // 如果图表未初始化或不在当前标签页，不更新
        if (!this.chartInitialized || this.activeTabIndex !== 0) {
          return;
        }
        
        // 检查图表是否准备好
        if (!chartManager.isChartReady(chartId)) {
          console.log(`图表 ${chartId} 尚未准备好，尝试重新初始化`);
          // 如果图表未准备好，尝试重新初始化
          if (this.$refs.chartRef) {
            setTimeout(() => {
              this.initChart().then(() => {
                // 初始化成功后重试更新
                if (this.chartInitialized) {
                  this.updateChart(data);
                }
              });
            }, 100);
          }
          return;
        }
        
        // 确保数据是有效的数组
        if (!Array.isArray(data)) {
          console.warn('更新图表数据无效:', data);
          return;
        }

        // 处理数据超过100个点的情况
        let displayData = [];
        try {
          displayData = [...data]; // 复制数组，防止修改原始数据
        } catch (e) {
          console.error('复制数据数组错误:', e);
          displayData = Array.isArray(data) ? data.slice() : [];
        }
        
        // 默认x轴显示0-100
        let xAxisData = Array.from({ length: 101 }, (_, i) => i);
        
        // 如果数据超过100个点，只显示最新的100个点
        if (data.length > 100) {
          try {
            // 取最新的100个数据点
            displayData = data.slice(-100);
            
            // 更新x轴数据，显示对应的索引
            const startIndex = data.length - 100;
            xAxisData = Array.from({ length: 100 }, (_, i) => startIndex + i);
          } catch (e) {
            console.error('处理图表数据时出错:', e);
          }
        }
        
        // 更新图表数据
        const newOption = {
          ...this.option,
          xAxis: {
            ...this.option.xAxis,
            data: xAxisData
          },
          series: [{
            ...this.option.series[0],
            data: displayData
          }]
        };
        
        // 使用图表管理器更新图表，通过队列处理避免频繁更新导致的卡顿
        chartManager.updateChart(chartId, newOption, {
          notMerge: false,
          lazyUpdate: true,
          silent: true
        }).catch(err => {
          console.error(`更新图表 ${chartId} 失败:`, err);
        });
        
        // 计算并更新EIT变化率
        this.calculateEITChangeRate();
      } catch (error) {
        console.error('更新图表时发生错误:', error);
      }
    },

    /**
     * 计算EIT变化率
     * 公式：(最大值-最小值)/最小值*100
     */
    calculateEITChangeRate() {
      // 如果当前正在显示最终变化率，则不重新计算
      if (this.isShowingFinalRate) {
        return;
      }
      
      // 根据当前选择的脑区获取对应的数据数组
      const dataArray = this.selectedBrain === 'left' ? LeftBrainData : RightBrainData
      
      // 过滤掉不是数字的值
      const validData = dataArray.filter(value => 
        typeof value === 'number' && !isNaN(value) && isFinite(value)
      )
      
      // 如果数组为空或只有一个元素，则变化率为0
      if (!validData || validData.length <= 1) {
        this.eitChangeRate = '0%'
        return
      }
      
      // 计算最大值和最小值
      const max = Math.max(...validData)
      const min = Math.min(...validData)
      
      // 如果最小值为0，为避免除以0的错误，将变化率设为无穷大或特定值
      if (min === 0) {
        this.eitChangeRate = '∞%'
        return
      }
      
      // 计算变化率：(最大值-最小值)/最小值*100
      const changeRate = ((max - min) / min) * 100
      
      // 格式化变化率，保留2位小数
      this.eitChangeRate = changeRate.toFixed(2) + '%'
      
      console.log(`${this.selectedBrain}脑EIT变化率: ${this.eitChangeRate}, 最大值: ${max}, 最小值: ${min}, 有效数据: ${validData.length}/${dataArray.length}`)
    },

    /**
     * 关闭弹框
     * 向父组件发送关闭事件
     */
    closeDialog() {
      // 如果是工装标签页，直接关闭弹框
      if (this.activeTabIndex === 4) {
        // 清空阻抗数据
        this.clearImpedanceData(false)

        // 断开蓝牙连接
        if (this.isConnected) {
          console.log('关闭弹框时断开蓝牙连接')
          uni.closeBLEConnection({
            deviceId: this.$store.state.deviceId,
            success: () => {
              console.log('蓝牙连接已断开')
              // 更新连接状态
              this.setIsConnected(false)
            },
            fail: (error) => {
              console.error('断开蓝牙连接失败：', error)
            },
          })
        }

        // 向父组件发送关闭事件
        this.$emit('close')
        return
      }

      // 如果正在监测，先弹出停止监测确认弹框
      if (this.monitoringStarted) {
        this.fromCloseButton = true // 标记是从关闭按钮触发的
        return // 不继续执行关闭操作，由MonitoringControl组件处理
      }

      // 清空所有数据，包括最终变化率
      this.clearImpedanceData(false)
      
      // 清空最终变化率相关标记
      this.isShowingFinalRate = false
      this.finalEitChangeRates = { left: ['0%', '0%', '0%', '0%'], right: ['0%', '0%', '0%', '0%'] }
      
      // 重置变化率为0%
      this.eitChangeRate = '0%';
      writeBLEState(50)
      // 向父组件发送关闭事件
      setTimeout(() =>{
        this.$emit('close')
      },600)

    },    /**
     * 处理标签页切换
     * @param {Number} index - 标签页索引
     */
    handleTabChanged(index) {
      // 如果正在监测，不允许切换到其他标签页
      if (this.monitoringStarted && this.activeTabIndex !== index) {
        uni.showToast({
          title: '监测中，无法切换标签页',
          icon: 'none',
          duration: 2000,
        });
        return;
      }
      
      // 如果切换到不同的标签页，释放所有图表资源
      if (this.activeTabIndex !== index) {
        console.log(`切换标签页: 从 ${this.activeTabIndex} 到 ${index}`);
        
        // 先释放当前图表资源，并等待释放完成后再初始化新图表
        this.disposeCurrentChart().then(() => {
          // 更新标签页索引
          this.activeTabIndex = index;
          
          // 如果有保存的最终变化率，则显示对应标签页的最终变化率
          if (this.isShowingFinalRate) {
            this.eitChangeRate = this.finalEitChangeRates[this.selectedBrain][index];
          } else {
            // 重置变化率为0%
            this.eitChangeRate = '0%';
          }
          
          // 延迟一下再初始化新图表，确保DOM已更新
          setTimeout(() => {
            this.initializeTabChart();
          }, 50);
        }).catch(error => {
          console.error('释放当前图表资源时出错:', error);
          // 即使出错也继续处理
          this.activeTabIndex = index;
          this.initializeTabChart();
        });
        
        // 强制进行垃圾回收
        setTimeout(() => {
          // 空函数，帮助触发垃圾回收
          console.log('标签页切换，触发垃圾回收');
        }, 100);
        
        // 由于后续已在Promise中处理，此处return阻止继续执行
        return;
      }

    // 如果切换到工装标签页，断开蓝牙连接
      if (index === 4) {
        // 如果正在监测，先停止监测
        if (this.monitoringStarted) {
          // 调用蓝牙通信函数停止监测
          writeBLEState(99)
          this.monitoringStarted = false

          // 提示用户已停止监测
          uni.showToast({
            title: '已停止监测',
            icon: 'success',
            duration: 2000,
          })
          
          // 停止监测时重置图表
          this.clearImpedanceData()
        }

        // 不再在切换到工装标签页时断开蓝牙连接
        // 让工装标签页组件自己管理蓝牙连接状态
        console.log('切换到工装标签页，不断开连接')
      }

      // 重置EIT值变化率
      this.eitChangeRate = '0%'
      
      // 根据切换到的标签页初始化对应的图表
      this.$nextTick(() => {
        if (index === 0) {
          this.initChart()
        } else if (index === 1) {
          this.initChart1()
        } else if (index === 2) {
          this.initChart2()
        } else if (index === 3) {
          this.initChart3()
        }
      })
    },    /**
     * 释放当前图表资源
     * @returns {Promise} 返回一个Promise，图表释放完成时resolve
     */
    disposeCurrentChart() {
      try {
        console.log('释放当前图表资源');
        
        // 使用图表管理器来可靠地销毁当前图表
        let chartId = null;
        
        // 根据当前标签页确定图表ID
        if (this.activeTabIndex === 0) {
          chartId = `sensitivity-${this.selectedBrain}`;
          this.chartInitialized = false;
        } else if (this.activeTabIndex === 1) {
          chartId = `stability-${this.selectedBrain}`;
          this.chart1Initialized = false;
        } else if (this.activeTabIndex === 2) {
          chartId = `accuracy-${this.selectedBrain}`;
          this.chart2Initialized = false;
        } else if (this.activeTabIndex === 3) {
          chartId = `thermalStability-${this.selectedBrain}`;
          this.chart3Initialized = false;
        }
        
        if (chartId) {
          // 使用图表管理器销毁图表，返回Promise
          return chartManager.disposeChart(chartId)
            .then(() => {
              console.log(`图表 ${chartId} 已成功销毁`);
            })
            .catch(error => {
              console.error(`销毁图表 ${chartId} 时出错:`, error);
            });
        }
        
        // 如果没有有效的chartId，直接返回已解决的Promise
        return Promise.resolve();
      } catch (error) {
        console.error('释放当前图表资源时发生错误:', error);
        return Promise.resolve(); // 返回一个已解决的Promise
      }
    },

    /**
     * 旧的图表销毁方法，用于兼容
     */
    disposeCurrentChartLegacy() {
      try {
        // 根据当前activeTabIndex释放对应图表
        if (this.activeTabIndex === 0 && this.chartInitialized) {
          if (this.$refs.chartRef) {
            return this.$refs.chartRef.init(echarts).then(chart => {
              try {
                chart.clear();
                chart.dispose();
                this.chartInitialized = false;
                console.log('系统灵敏度图表资源已释放');
                return Promise.resolve();
              } catch (error) {
                console.error('释放系统灵敏度图表资源时出错:', error);
                return Promise.resolve();
              }
            }).catch(err => {
              console.error('初始化系统灵敏度图表失败:', err);
              return Promise.resolve();
            });
          }
        } else if (this.activeTabIndex === 1 && this.chart1Initialized) {
          if (this.$refs.chartRef1) {
            this.$refs.chartRef1.init(echarts).then(chart => {
              try {
                chart.clear();
                chart.dispose();
                this.chart1Initialized = false;
                console.log('系统稳定性图表资源已释放');
              } catch (error) {
                console.error('释放系统稳定性图表资源时出错:', error);
              }
            }).catch(err => {
              console.error('初始化系统稳定性图表失败:', err);
            });
          }
        } else if (this.activeTabIndex === 2 && this.chart2Initialized) {
          if (this.$refs.chartRef2) {
            this.$refs.chartRef2.init(echarts).then(chart => {
              try {
                chart.clear();
                chart.dispose();
                this.chart2Initialized = false;
                console.log('测量精度图表资源已释放');
              } catch (error) {
                console.error('释放测量精度图表资源时出错:', error);
              }
            }).catch(err => {
              console.error('初始化测量精度图表失败:', err);
            });
          }
        } else if (this.activeTabIndex === 3 && this.chart3Initialized) {
          if (this.$refs.chartRef3) {
            this.$refs.chartRef3.init(echarts).then(chart => {
              try {
                chart.clear();
                chart.dispose();
                this.chart3Initialized = false;
                console.log('热稳定性测试图表资源已释放');
              } catch (error) {
                console.error('释放热稳定性测试图表资源时出错:', error);
              }
            }).catch(err => {
              console.error('初始化热稳定性测试图表失败:', err);
            });
          }
        }
      } catch (error) {
        console.error('释放当前图表资源时发生错误:', error);
      }
    },

    /**
     * 释放所有图表资源
     */
    disposeAllCharts() {
      try {
        console.log('开始释放所有图表资源');
        
        // 使用图表管理器销毁所有图表
        return chartManager.disposeAllCharts()
          .then(() => {
            // 重置所有图表初始化状态
            this.chartInitialized = false;
            this.chart1Initialized = false;
            this.chart2Initialized = false;
            this.chart3Initialized = false;
            
            console.log('所有图表资源已成功释放');
          })
          .catch(error => {
            console.error('释放所有图表资源时出错:', error);
          });
      } catch (error) {
        console.error('释放所有图表资源时发生错误:', error);
        return Promise.resolve();
      }
    },

    /**
     * 处理监测开始
     */
    handleMonitoringStarted() {
      console.log('监测已开始')
      
      // 开始监测时重置所有数据，包括变化率
      this.clearImpedanceData(false)
      
      // 清除最终变化率标记
      this.isShowingFinalRate = false
      
      // 记录开始时间
      this.startTime = Date.now();
      this.monitorTime = 0;
      
      // 重置更新阈值为初始值
      this.updateThreshold = 1;
      
      // 启动计时器
      this.timerInterval = setInterval(() => {
        this.monitorTime++;
        
        // 根据监测时间动态调整更新频率
        this.adjustUpdateThreshold();
        
        // 检查是否达到时间限制
        if (this.activeTabIndex === 1 && this.monitorTime >= 3600) { // 系统稳定性 1小时
          this.handleTimeUp();
        } else if (this.activeTabIndex === 2 && this.monitorTime >= 1200) { // 测量精度 20分钟
          this.handleTimeUp();
        }
        
        // 每5分钟执行一次数据优化
        if (this.monitorTime % 300 === 0) {
          this.optimizeDataStorage();
        }
      }, 1000);
      
      // 启动内存回收计时器，每60秒执行一次内存回收
      this.memoryCleanupInterval = setInterval(() => {
        this.performMemoryCleanup();
      }, 60000);
    },
    
    /**
     * 根据监测时间动态调整更新频率
     */
    adjustUpdateThreshold() {
      // 遍历所有阶段，找到当前应该应用的阈值
      for (let i = this.updatePhases.length - 1; i >= 0; i--) {
        const phase = this.updatePhases[i];
        if (this.monitorTime >= phase.time) {
          // 如果阈值发生变化，记录日志
          if (this.updateThreshold !== phase.threshold) {
            console.log(`监测时间 ${this.formatTime(this.monitorTime)}，更新频率调整为: 每${phase.threshold}次更新图表`);
            this.updateThreshold = phase.threshold;
          }
          return; // 找到适用的阶段后返回
        }
      }
      
      // 如果没有找到适用的阶段，使用默认值1
      if (this.updateThreshold !== 1) {
        this.updateThreshold = 1;
      }
    },
    
    /**
     * 格式化时间为小时:分钟:秒
     */
    formatTime(seconds) {
      const hours = Math.floor(seconds / 3600).toString().padStart(2, '0');
      const minutes = Math.floor((seconds % 3600) / 60).toString().padStart(2, '0');
      const secs = Math.floor(seconds % 60).toString().padStart(2, '0');
      return `${hours}:${minutes}:${secs}`;
    },

    /**
     * 优化数据存储，只保留必要的数据点
     * 该方法保留数据模式，只在内部处理
     */
    optimizeDataStorage() {
      try {
        console.log('开始优化数据存储');
        
        // 保留当前显示的数据和重要性能指标
        const currentBrainData = this.selectedBrain === 'left' ? LeftBrainData : RightBrainData;
        
        if (currentBrainData.length > 5000) {
          // 根据当前更新阈值确定数据采样率，更新频率越低，采样率越大
          const samplingRate = Math.max(10, this.updateThreshold * 10); // 采样率与更新阈值成正比
          
          // 从大量数据中提取关键点:
          // 1. 保留最新的数据以保持最新显示
          const recentDataCount = Math.min(currentBrainData.length, 2000); // 最新2000个点
          const recentData = currentBrainData.slice(-recentDataCount);
          
          // 从旧数据中取样
          const oldData = currentBrainData.slice(0, -recentDataCount);
          const sampledOldData = [];
          
          for (let i = 0; i < oldData.length; i += samplingRate) {
            sampledOldData.push(oldData[i]);
          }
          
          // 替换原始数据数组
          const optimizedData = [...sampledOldData, ...recentData];
          
          if (this.selectedBrain === 'left') {
            console.log(`左脑数据优化: ${currentBrainData.length} -> ${optimizedData.length}，采样率: ${samplingRate}`);
            LeftBrainData = optimizedData;
          } else {
            console.log(`右脑数据优化: ${currentBrainData.length} -> ${optimizedData.length}，采样率: ${samplingRate}`);
            RightBrainData = optimizedData;
          }
          
          // 更新图表显示
          this.performMemoryCleanup();
        }
      } catch (error) {
        console.error('优化数据存储时发生错误:', error);
      }
    },

    /**
     * 处理监测停止
     */
    handleMonitoringStopped() {
      console.log('监测已停止')
      writeBLEState(99)
      
      // 保存当前变化率为最终变化率
      this.saveFinalChangeRate()
      
      // 停止计时器
      if (this.timerInterval) {
        clearInterval(this.timerInterval);
        this.timerInterval = null;
      }
      
      // 停止内存回收计时器
      if (this.memoryCleanupInterval) {
        clearInterval(this.memoryCleanupInterval);
        this.memoryCleanupInterval = null;
      }
      
      // 重置更新阈值为初始值
      this.updateThreshold = 1;
      this.updateCounter = 0;
      
      // 监测停止时重置图表，但保留最终变化率
      this.clearImpedanceData(true)

    },
    
    /**
     * 保存当前变化率为最终变化率
     */
    saveFinalChangeRate() {
      // 根据当前标签页和脑区保存最终变化率
      this.finalEitChangeRates[this.selectedBrain][this.activeTabIndex] = this.eitChangeRate
      console.log(`保存${this.selectedBrain}脑${this.tabs[this.activeTabIndex].name}的最终变化率: ${this.eitChangeRate}`)
      
      // 标记当前显示的是最终变化率
      this.isShowingFinalRate = true
    },
    
    /**
     * 执行内存回收操作
     */
    performMemoryCleanup() {
      console.log('执行内存回收操作');
      
      try {
        // 释放不必要的内存
        if (typeof window !== 'undefined' && window.gc) {
          window.gc();
        }
        
        // 进行图表对象的内部清理
        const activeChartRef = this.getActiveChartRef();
        if (activeChartRef) {
          activeChartRef.init(echarts).then(chart => {
            try {
              // 使用轻量级刷新方式
              chart.clear();
              // 重新渲染图表
              const dataArray = this.selectedBrain === 'left' ? LeftBrainData : RightBrainData;
              
              // 只显示最后100个数据点，但保持正确的x轴索引
              const displayData = dataArray.length > 100 
                ? dataArray.slice(-100) 
                : dataArray;
              
              const xAxisData = dataArray.length > 100
                ? Array.from({ length: 100 }, (_, i) => dataArray.length - 100 + i)
                : Array.from({ length: dataArray.length }, (_, i) => i);
                
              // 更新图表
              const newOption = {
                ...this.option,
                xAxis: {
                  ...this.option.xAxis,
                  data: xAxisData
                },
                series: [{
                  ...this.option.series[0],
                  data: displayData
                }]
              };
              
              chart.setOption(newOption, {
                notMerge: false,
                lazyUpdate: true,
                silent: true
              });
            } catch (error) {
              console.error('刷新图表出错:', error);
            }
          });
        }
      } catch (error) {
        console.error('内存回收时发生错误:', error);
      }
      
      // 强制进行垃圾回收
      setTimeout(() => {
        // 空函数，帮助触发垃圾回收
        console.log('触发垃圾回收完成');
      }, 0);
    },
    
    /**
     * 获取当前活动的图表引用
     */
    getActiveChartRef() {
      if (this.activeTabIndex === 0 && this.chartInitialized) {
        return this.$refs.chartRef;
      } else if (this.activeTabIndex === 1 && this.chart1Initialized) {
        return this.$refs.chartRef1;
      } else if (this.activeTabIndex === 2 && this.chart2Initialized) {
        return this.$refs.chartRef2;
      } else if (this.activeTabIndex === 3 && this.chart3Initialized) {
        return this.$refs.chartRef3;
      }
      return null;
    },
    
    /**
     * 处理时间到
     */
    handleTimeUp() {
      // 保存当前变化率为最终变化率
      this.saveFinalChangeRate();
      
      // 停止监测
      this.monitoringStarted = false;
      
      // 停止计时器
      if (this.timerInterval) {
        clearInterval(this.timerInterval);
        this.timerInterval = null;
      }
      
      // 调用蓝牙通信函数停止监测
      writeBLEState(99);
      
      // 提示用户检测时间已到
      uni.showToast({
        title: '检测时间已到',
        icon: 'success',
        duration: 2000,
      });
      
      // 保存当前的监测时间，用于显示最终结果
      const finalTime = this.monitorTime;
      
      // 清空阻抗数据但不重置变化率，保留最终结果
      this.clearImpedanceData(true);
    },
    
    /**
     * 清空阻抗数据但保留图表
     */
    clearImpedanceDataButKeepChart() {
      // 重置EIT值变化率
      this.eitChangeRate = '0%';
      
      // 重置实时阻抗值
      this.currentLeftImpedance = 0;
      this.currentRightImpedance = 0;
      
      // 重置监测时间
      this.startTime = null;
      this.monitorTime = 0;
      
      // 停止计时器
      if (this.timerInterval) {
        clearInterval(this.timerInterval);
        this.timerInterval = null;
      }
      
      // 重置更新时间戳
      this.lastLeftUpdateTime = null;
      this.lastRightUpdateTime = null;
      
      console.log('阻抗数据已清空，但保留图表显示');
    },

    /**
     * 清空阻抗数据
     * @param {Boolean} keepFinalRate - 是否保留最终变化率，默认为false
     */
    clearImpedanceData(keepFinalRate = false) {
      // 如果显示的是最终变化率，并且需要保留，则不重置变化率
      if (!this.isShowingFinalRate || !keepFinalRate) {
        // 重置EIT值变化率
        this.eitChangeRate = '0%'
      } else if (keepFinalRate && this.isShowingFinalRate) {
        // 如果保留最终变化率，从保存的值中恢复
        this.eitChangeRate = this.finalEitChangeRates[this.selectedBrain][this.activeTabIndex]
      }
      
      // 重置实时阻抗值
      this.currentLeftImpedance = 0
      this.currentRightImpedance = 0
      
      // 重置监测时间
      this.startTime = null;
      this.monitorTime = 0;
      
      // 停止计时器
      if (this.timerInterval) {
        clearInterval(this.timerInterval);
        this.timerInterval = null;
      }
      
      // 重置所有图表数据
      this.resetCharts()
      
      // 清空数据数组
      LeftBrainData = []
      RightBrainData = []
      
      // 重置更新时间戳
      this.lastLeftUpdateTime = null
      this.lastRightUpdateTime = null
      
      // 强制进行垃圾回收
      setTimeout(() => {
        // 空函数，帮助触发垃圾回收
      }, 0);
      
      console.log('阻抗数据已清空，左右脑数据、最大最小值和起始索引已重置')
      
      // 如果不保留最终变化率，则清空最终变化率相关数据
      if (!keepFinalRate) {
        // 清空最终变化率
        this.finalEitChangeRates = { left: ['0%', '0%', '0%', '0%'], right: ['0%', '0%', '0%', '0%'] }
        // 清空最终变化率标记
        this.isShowingFinalRate = false
      }
    },
    
    /**
     * 重置所有图表
     */
    resetCharts() {
      // 重置系统灵敏度图表
      if (this.$refs.chartRef) {
        this.$refs.chartRef.init(echarts).then(chart => {
          const newOption = {
            ...this.option,
            xAxis: {
              ...this.option.xAxis,
              data: Array.from({ length: 101 }, (_, i) => i) // 重置为0-100的x轴
            },
            series: [{
              ...this.option.series[0],
              data: []
            }]
          }
          chart.setOption(newOption, {
            notMerge: false,
            lazyUpdate: true,
            silent: true
          })
        })
      }
      
      // 重置系统稳定性图表
      if (this.$refs.chartRef1) {
        this.$refs.chartRef1.init(echarts).then(chart => {
          const newOption = {
            ...this.option,
            xAxis: {
              ...this.option.xAxis,
              data: Array.from({ length: 101 }, (_, i) => i) // 重置为0-100的x轴
            },
            series: [{
              ...this.option.series[0],
              data: []
            }]
          }
          chart.setOption(newOption, {
            notMerge: false,
            lazyUpdate: true,
            silent: true
          })
        })
      }
      
      // 重置测量精度图表
      if (this.$refs.chartRef2) {
        this.$refs.chartRef2.init(echarts).then(chart => {
          const newOption = {
            ...this.option,
            xAxis: {
              ...this.option.xAxis,
              data: Array.from({ length: 101 }, (_, i) => i) // 重置为0-100的x轴
            },
            series: [{
              ...this.option.series[0],
              data: []
            }]
          }
          chart.setOption(newOption, {
            notMerge: false,
            lazyUpdate: true,
            silent: true
          })
        })
      }
      
      // 重置热稳定性测试图表
      if (this.$refs.chartRef3) {
        this.$refs.chartRef3.init(echarts).then(chart => {
          const newOption = {
            ...this.option,
            xAxis: {
              ...this.option.xAxis,
              data: Array.from({ length: 101 }, (_, i) => i) // 重置为0-100的x轴，与其他图表保持一致
            },
            series: [{
              ...this.option.series[0],
              data: []
            }]
          }
          chart.setOption(newOption, {
            notMerge: false,
            lazyUpdate: true,
            silent: true
          })
        })
      }
      
      console.log('所有图表已重置')

    },
      /**
     * 切换脑区
     * @param {String} brain - 脑区类型，'left'或'right'
     */
    switchBrain(brain) {
      if (this.selectedBrain === brain) return

      // 如果正在监测中，不允许切换
      if (this.monitoringStarted) return

      // 记录旧脑区
      const oldBrain = this.selectedBrain;
      console.log(`从${oldBrain}脑切换到${brain}脑`);
      
      // 在切换脑区前释放所有图表资源，并等待释放完成
      this.disposeAllCharts().then(() => {
        // 更新当前选中的脑区
        this.selectedBrain = brain;
        
        // 如果有保存的最终变化率，则显示对应脑区的最终变化率
        if (this.isShowingFinalRate) {
          this.eitChangeRate = this.finalEitChangeRates[brain][this.activeTabIndex];
        } else {
          // 重置变化率为0%
          this.eitChangeRate = '0%';
        }
        
        // 延迟一下再初始化图表，确保DOM已更新
        setTimeout(() => {
          this.initializeTabChart();
        }, 100);
      }).catch(error => {
        console.error('释放图表资源时出错:', error);
        
        // 即使出错也继续切换脑区
        this.selectedBrain = brain;
        setTimeout(() => {
          this.initializeTabChart();
        }, 100);
      });
      
      // 强制进行垃圾回收
      setTimeout(() => {
        // 空函数，帮助触发垃圾回收
        console.log('脑区切换，触发垃圾回收');
      }, 200);
    },

    // 系统稳定性图表初始化
    async initChart1() {
      if (!this.$refs.chartRef1) return;
      
      try {
        const chart = await this.$refs.chartRef1.init(echarts);
        
        // 初始化图表
        const initialOption = {
          ...this.option,
          xAxis: {
            ...this.option.xAxis,
            data: Array.from({ length: 101 }, (_, i) => i) // 初始显示0-100的x轴
          },
          series: [{
            ...this.option.series[0],
            data: [] // 初始为空
          }]
        };
        chart.setOption(initialOption);
        
        // 标记图表已初始化
        this.chart1Initialized = true;
        
        // 初始化图表后，根据当前选择的脑区显示数据
        if (this.activeTabIndex === 1) {
          const data = this.selectedBrain === 'left' ? LeftBrainData : RightBrainData;
          this.updateChart1(data);
        }
        
        console.log('系统稳定性图表初始化完成');
      } catch (error) {
        console.error('初始化系统稳定性图表失败:', error);
      }
    },
    
    // 测量精度图表初始化
    async initChart2() {
      if (!this.$refs.chartRef2) return;
      
      try {
        const chart = await this.$refs.chartRef2.init(echarts);
        
        // 初始化图表
        const initialOption = {
          ...this.option,
          xAxis: {
            ...this.option.xAxis,
            data: Array.from({ length: 101 }, (_, i) => i) // 初始显示0-100的x轴
          },
          series: [{
            ...this.option.series[0],
            data: [] // 初始为空
          }]
        };
        chart.setOption(initialOption);
        
        // 标记图表已初始化
        this.chart2Initialized = true;
        
        // 初始化图表后，根据当前选择的脑区显示数据
        if (this.activeTabIndex === 2) {
          const data = this.selectedBrain === 'left' ? LeftBrainData : RightBrainData;
          this.updateChart2(data);
        }
        
        console.log('测量精度图表初始化完成');
      } catch (error) {
        console.error('初始化测量精度图表失败:', error);
      }
    },
    
    // 热稳定性测试图表初始化
    async initChart3() {
      if (!this.$refs.chartRef3) return;
      
      try {
        const chart = await this.$refs.chartRef3.init(echarts);
        
        // 初始化图表
        const initialOption = {
          ...this.option,
          xAxis: {
            ...this.option.xAxis,
            data: Array.from({ length: 101 }, (_, i) => i) // 初始显示0-100的x轴，与系统灵敏度保持一致
          },
          series: [{
            ...this.option.series[0],
            data: [] // 初始为空
          }]
        };
        chart.setOption(initialOption);
        
        // 标记图表已初始化
        this.chart3Initialized = true;
        
        // 初始化图表后，根据当前选择的脑区显示数据
        if (this.activeTabIndex === 3) {
          const data = this.selectedBrain === 'left' ? LeftBrainData : RightBrainData;
          this.updateChart3(data);
        }
        
        console.log('热稳定性测试图表初始化完成');
      } catch (error) {
        console.error('初始化热稳定性测试图表失败:', error);
      }
    },

    // 更新系统稳定性图表数据
    updateChart1(data) {
      if (!this.$refs.chartRef1) return
      
      this.$refs.chartRef1.init(echarts).then(chart => {
        try {
          // 处理数据超过100个点的情况
          let displayData = [...data]
          // 默认x轴显示0-100
          let xAxisData = Array.from({ length: 101 }, (_, i) => i)
          
          // 如果数据超过100个点，只显示最新的100个点
          if (data.length > 100) {
            // 取最新的100个数据点
            displayData = data.slice(-100)
            
            // 更新x轴数据，显示对应的索引
            const startIndex = data.length - 100
            xAxisData = Array.from({ length: 100 }, (_, i) => startIndex + i)
          } else {
            // 数据不足100个点时，仍然显示0-100的x轴，但只有前data.length个点有数据
            displayData = [...data]
            // 保持xAxisData不变，仍然是0-100
          }
          
          // 更新图表数据
          const newOption = {
            ...this.option,
            xAxis: {
              ...this.option.xAxis,
              data: xAxisData
            },
            series: [{
              ...this.option.series[0],
              data: displayData
            }]
          }
          
          // 直接设置选项，避免使用requestAnimationFrame
          setTimeout(() => {
            chart.setOption(newOption, {
              notMerge: false,
              lazyUpdate: true,
              silent: true
            })
          }, 0)
          
          // 计算并更新EIT变化率
          this.calculateEITChangeRate()
        } catch (error) {
          console.error('更新图表时发生错误:', error)
        }
      }).catch(err => {
        console.error('初始化图表失败:', err)
      })
    },
    
    // 更新测量精度图表数据
    updateChart2(data) {
      if (!this.$refs.chartRef2) return
      
      this.$refs.chartRef2.init(echarts).then(chart => {
        try {
          // 处理数据超过100个点的情况
          let displayData = [...data]
          // 默认x轴显示0-100
          let xAxisData = Array.from({ length: 101 }, (_, i) => i)
          
          // 如果数据超过100个点，只显示最新的100个点
          if (data.length > 100) {
            // 取最新的100个数据点
            displayData = data.slice(-100)
            
            // 更新x轴数据，显示对应的索引
            const startIndex = data.length - 100
            xAxisData = Array.from({ length: 100 }, (_, i) => startIndex + i)
          } else {
            // 数据不足100个点时，仍然显示0-100的x轴，但只有前data.length个点有数据
            displayData = [...data]
            // 保持xAxisData不变，仍然是0-100
          }
          
          // 更新图表数据
          const newOption = {
            ...this.option,
            xAxis: {
              ...this.option.xAxis,
              data: xAxisData
            },
            series: [{
              ...this.option.series[0],
              data: displayData
            }]
          }
          
          // 直接设置选项，避免使用requestAnimationFrame
          setTimeout(() => {
            chart.setOption(newOption, {
              notMerge: false,
              lazyUpdate: true,
              silent: true
            })
          }, 0)
          
          // 计算并更新EIT变化率
          this.calculateEITChangeRate()
        } catch (error) {
          console.error('更新图表时发生错误:', error)
        }
      }).catch(err => {
        console.error('初始化图表失败:', err)
      })
    },
    
    // 更新热稳定性测试图表数据
    updateChart3(data) {
      if (!this.$refs.chartRef3) return
      
      this.$refs.chartRef3.init(echarts).then(chart => {
        try {
          // 处理数据超过100个点的情况
          let displayData = [...data]
          // 默认x轴显示0-100
          let xAxisData = Array.from({ length: 101 }, (_, i) => i)
          
          // 如果数据超过100个点，只显示最新的100个点
          if (data.length > 100) {
            // 取最新的100个数据点
            displayData = data.slice(-100)
            
            // 更新x轴数据，显示对应的索引
            const startIndex = data.length - 100
            xAxisData = Array.from({ length: 100 }, (_, i) => startIndex + i)
          } else {
            // 数据不足100个点时，仍然显示0-100的x轴，但只有前data.length个点有数据
            displayData = [...data]
            // 保持xAxisData不变，仍然是0-100
          }
          
          // 更新图表数据
          const newOption = {
            ...this.option,
            xAxis: {
              ...this.option.xAxis,
              data: xAxisData
            },
            series: [{
              ...this.option.series[0],
              data: displayData
            }]
          }
          
          // 直接设置选项，避免使用requestAnimationFrame
          setTimeout(() => {
            chart.setOption(newOption, {
              notMerge: false,
              lazyUpdate: true,
              silent: true
            })
          }, 0)
          
          // 计算并更新EIT变化率
          this.calculateEITChangeRate()
        } catch (error) {
          console.error('更新图表时发生错误:', error)
        }
      }).catch(err => {
        console.error('初始化图表失败:', err)
      })
    },

    /**
     * 智能降采样方法
     * 根据数据量动态调整采样策略，确保图表持续滚动显示最新数据
     * @param {String} brainType - 脑区类型，'left'或'right'
     */
    intelligentDownsampling(brainType) {
      try {
        // 获取当前脑区数据
        const dataArray = brainType === 'left' ? LeftBrainData : RightBrainData;
        
        // 如果数据量未达到最大限制，直接返回
        if (dataArray.length <= MAX_DATA_POINTS) {
          return;
        }
        
        // 计算当前数据量占最大限制的百分比
        const dataRatio = dataArray.length / MAX_DATA_POINTS;
        
        // 动态计算降采样比例，随着数据量增加而增加
        // 例如：数据量是最大限制的1.5倍时，保留2/3的数据
        //      数据量是最大限制的2倍时，保留1/2的数据
        const samplingFactor = Math.max(1, Math.ceil(dataRatio));
        
        // 计算保留数据点的数量（确保至少保留8000个数据点用于滚动显示）
        const preserveCount = Math.max(8000, Math.floor(MAX_DATA_POINTS / samplingFactor));
        
        // 始终保留最新的1000个数据点，确保最新数据完整显示
        const latestDataCount = 1000;
        const latestData = dataArray.slice(-latestDataCount);
        
        // 对历史数据进行降采样
        const historicalData = dataArray.slice(0, -latestDataCount);
        
        // 计算历史数据需要保留的点数
        const historicalPreserveCount = preserveCount - latestDataCount;
        
        // 如果历史数据少于需要保留的点数，全部保留
        let sampledHistoricalData = [];
        if (historicalData.length <= historicalPreserveCount) {
          sampledHistoricalData = [...historicalData];
        } else {
          // 否则进行均匀采样
          const stride = Math.ceil(historicalData.length / historicalPreserveCount);
          
          // 对历史数据进行降采样，同时保留关键点（极值点）
          const keyPoints = new Set(); // 用于存储要保留的关键点索引
          
          // 找出局部极值点（波峰波谷）
          for (let i = 1; i < historicalData.length - 1; i++) {
            const prev = historicalData[i-1];
            const curr = historicalData[i];
            const next = historicalData[i+1];
            
            // 如果是局部最大值或最小值
            if ((curr > prev && curr > next) || (curr < prev && curr < next)) {
              keyPoints.add(i);
            }
          }
          
          // 均匀采样的同时，优先保留关键点
          for (let i = 0; i < historicalData.length; i += stride) {
            sampledHistoricalData.push(historicalData[i]);
            
            // 在当前步长内查找并添加关键点
            for (let j = i + 1; j < Math.min(i + stride, historicalData.length); j++) {
              if (keyPoints.has(j)) {
                sampledHistoricalData.push(historicalData[j]);
              }
            }
          }
        }
        
        // 合并降采样后的历史数据和最新数据
        const optimizedData = [...sampledHistoricalData, ...latestData];
        
        console.log(`${brainType}脑数据降采样: ${dataArray.length} -> ${optimizedData.length}, 采样因子: ${samplingFactor}`);
        
        // 更新数据数组
        if (brainType === 'left') {
          LeftBrainData = optimizedData;
        } else {
          RightBrainData = optimizedData;
        }
      } catch (error) {
        console.error('智能降采样出错:', error);
      }
    },

    /**
     * 初始化当前标签页的图表
     * 这个辅助方法确保在正确的时机初始化图表
     */
    initializeTabChart() {
      console.log(`开始初始化标签页 ${this.activeTabIndex} 的图表`);
      
      // 根据当前标签页索引初始化对应图表
      if (this.activeTabIndex === 0) {
        this.initChart();
      } else if (this.activeTabIndex === 1) {
        this.initChart1();
      } else if (this.activeTabIndex === 2) {
        this.initChart2();
      } else if (this.activeTabIndex === 3) {
        this.initChart3();
      }
    },
  },

  /**
   * 组件挂载后初始化
   */
  mounted() {
    // 初始化
    this.$nextTick(() => {
      // 确保阻抗数据为空
      this.clearImpedanceData()
      
      // 只初始化当前激活的标签页图表
      if (this.activeTabIndex === 0) {
        this.initChart()
      } else if (this.activeTabIndex === 1) {
        this.initChart1()
      } else if (this.activeTabIndex === 2) {
        this.initChart2()
      } else if (this.activeTabIndex === 3) {
        this.initChart3()
      }
    })
  },

  /**
   * 组件销毁前清理
   */
  beforeDestroy() {
    // 释放所有图表资源
    this.disposeAllCharts();
    
    // 清空阻抗数据
    this.clearImpedanceData()

    // 如果还在监测，停止监测
    if (this.monitoringStarted) {
      writeBLEState(99)
    }

    // 停止计时器
    if (this.timerInterval) {
      clearInterval(this.timerInterval);
      this.timerInterval = null;
    }
    
    // 停止内存回收计时器
    if (this.memoryCleanupInterval) {
      clearInterval(this.memoryCleanupInterval);
      this.memoryCleanupInterval = null;
    }

    // 如果蓝牙还连接着，断开连接
    if (this.isConnected) {
      uni.closeBLEConnection({
        deviceId: this.$store.state.deviceId,
        fail: (error) => {
          console.error('断开蓝牙连接失败：', error)
        },
      })
    }
    
    // 释放变量引用
    LeftBrainData = []
    RightBrainData = []
  },
}
</script>

<style scoped lang="scss">
.dialog-content {
  padding: 20px;
  padding-top: 5px;
  min-height: 300px;
  max-height: 500px;
  overflow-y: auto;

  .tab-pane {
    height: 100%;
    max-height: 400px;
    overflow-y: auto;
  }
}

.dialog-footer {
  padding: 16px 20px;
  padding-top: 5px;
  padding-bottom: 5px;
  border-top: 1px solid #eee;
}

.chart-container {
  height: 210px;
  width: 100%;
}

.brain-tabs {
  display: flex;
  justify-content: center;
  margin-bottom: 15px;

  .brain-tab {
    cursor: pointer;
    padding: 6px 20px;
    border: 2px solid #ccc;
    border-radius: 20px;
    margin: 0 10px;
    font-size: 14px;
    transition: all 0.3s ease;
    min-width: 80px;
    text-align: center;
    background-color: #f5f5f5;
    color: #666;

    &:hover {
      color: #4a90e2;
      border-color: #4a90e2;
    }

    &.active {
      background-color: #4de6c2;
      color: #fff;
      border-color: #4de6c2;
      box-shadow: 0 2px 8px rgba(77, 230, 194, 0.3);
    }
    
    &.disabled {
      cursor: not-allowed;
      opacity: 0.6;
      background-color: #f0f0f0;
      color: #999;
      border-color: #ddd;
      
      &:hover {
        color: #999;
        border-color: #ddd;
      }
      
      &.active {
        background-color: #a8e8d4;
        color: #fff;
        border-color: #a8e8d4;
        box-shadow: none;
      }
    }
  }
}

.impedance-info {
  display: flex;
  justify-content: center;
  align-items: center;
  margin-bottom: 15px;
  background-color: #f8f8f8;
  padding: 10px 15px;
  border-radius: 8px;
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);

  .impedance-item {
    display: flex;
    align-items: center;

    .label {
      font-size: 14px;
      color: #666;
      margin-right: 5px;
    }

    .value {
      font-size: 16px;
      font-weight: bold;
      color: #4de6c2;
      margin-right: 20px;
    }
  }
}

.timer-info {
  display: flex;
  justify-content: space-between;
  align-items: center;
  margin-top: 15px;

  .timer-item {
    display: flex;
    align-items: center;

    .label {
      font-size: 14px;
      color: #666;
      margin-right: 8px;
      font-weight: bold;
    }

    .value {
      font-size: 16px;
      font-weight: bold;
      color: #4de6c2;
      background-color: rgba(77, 230, 194, 0.1);
      padding: 4px 10px;
      border-radius: 4px;
      min-width: 100px;
      text-align: center;
      letter-spacing: 1px;
    }
  }
}
</style>